home *** CD-ROM | disk | FTP | other *** search
/ MacHack 1996 / MacHack 1996.toast / Hacks / Hacks '96 / Fly Paper / FlyPaper Source / New Sources / ClippingFile.cpp next >
Encoding:
C/C++ Source or Header  |  1996-06-22  |  7.1 KB  |  332 lines  |  [TEXT/CWIE]
  1. #ifndef CLIPPINGFILE_H
  2. #include "ClippingFile.h"
  3. #endif
  4.  
  5. #ifndef ST_MACCLASSES_H
  6. #include "ST_MacClasses.h"
  7. #endif
  8.  
  9. #ifndef CLIPPINGFILEDATA_H
  10. #include "ClippingFileData.h"
  11. #endif
  12.  
  13. #ifndef FLYPAPERUTILS_H
  14. #include "FlyPaperUtils.h"
  15. #endif
  16.  
  17. #ifndef FLYPAPERDRAGUTILS_H
  18. #include "FlyPaperDragUtils.h"
  19. #endif
  20.  
  21.  
  22. CClippingFile::CClippingFile (FSSpec& fileOnDisk) :
  23.     fRefNum (0),
  24.     fClippingTOC (0),
  25.     fData (0)
  26. {
  27.     ST_ResFileSaver            saver = CurResFile ();
  28.     ST_ResFileCloser        ref = FSpOpenResFile (&fileOnDisk, fsRdWrPerm);
  29.     
  30.     if ((short) ref < 0)
  31.         throw ResError ();
  32.         
  33.     fRefNum = (short) ref;
  34.  
  35.     InitCClippingFile ();
  36.  
  37.     ref.Forget ();    
  38. }
  39.  
  40. CClippingFile::CClippingFile (short refNum) :
  41.     fRefNum (refNum),
  42.     fClippingTOC (0),
  43.     fData (0)
  44. {
  45.     ST_ResFileSaver            saver = CurResFile ();
  46.     UseResFile (refNum);
  47.     
  48.     InitCClippingFile ();
  49. }
  50.  
  51. CClippingFile* CClippingFile::NewClippingFileFromDragItem (DragReference dragRef, 
  52.         ItemReference itemRef, Point dropPoint, short tile)
  53. {
  54.     FSSpec            spec;
  55.     OSErr            error = FlyPaperFindFolder (kOnSystemDisk, kClippingsFolder, true,
  56.                             &spec.vRefNum, &spec.parID);
  57.     if (error)
  58.         throw error;
  59.         
  60.     NumToString (TickCount (), spec.name);
  61.     
  62.     CClippingFile*            file = nil;
  63.     unsigned short            howManyFlavors;
  64.  
  65.     error = CountDragItemFlavors (dragRef, itemRef, &howManyFlavors);
  66.     if (error)
  67.         throw error;
  68.  
  69.     for (unsigned short whichFlavor = 1; whichFlavor <= howManyFlavors; ++whichFlavor) {
  70.                             
  71.         if (AcceptableFlavor (dragRef, itemRef, whichFlavor)) {
  72.             if (file == nil) {
  73.                 file = NewClippingFile (spec);
  74.             }
  75.             
  76.             FlavorType        type;
  77.             FlavorFlags        flags;
  78.             Size            size;
  79.  
  80.             error = GetFlavorType (dragRef, itemRef, whichFlavor, &type);
  81.             if (error)
  82.                 throw error;
  83.             error = GetFlavorFlags (dragRef, itemRef, type, &flags);
  84.             if (error)
  85.                 throw error;
  86.                                     
  87.             error = GetFlavorDataSize (dragRef, itemRef, type, &size);
  88.             if (error)
  89.                 throw error;
  90.             
  91.             /* allocate memory for the drag item */
  92.             Handle            data = TempNewHandle (size, &error);
  93.             if (!data) {
  94.                 throw error;
  95.             }
  96.  
  97.             ST_Handle                    dataKiller (data);
  98.             {
  99.                 ST_HandleStateSaver     dataStateSaver (data);
  100.                 
  101.                 HLock (data);
  102.                 error = GetFlavorData (dragRef, itemRef, type, *data, &size, 0);
  103.                 if (error)
  104.                     throw error;
  105.             }
  106.                                         
  107.             file -> AddFlavor (type, data);
  108.             
  109.             WriteResource (data);
  110.             ReleaseResource (data);
  111.             dataKiller.Forget ();
  112.         }
  113.     }
  114.  
  115.     if (file) {
  116.         CClippingFileData*        data = file -> GetData ();
  117.         if (!data)
  118.             throw memFullErr;
  119.         
  120.         short            offset;
  121.         Boolean            onLeft;
  122.         
  123.         ClassifyPoint (dropPoint, &onLeft, &offset);
  124.         data -> SetOnLeft (onLeft);
  125.         data -> SetOffset (offset);
  126.  
  127.     
  128.     }
  129.  
  130.     return file;
  131. }
  132.  
  133. void CClippingFile::InitCClippingFile ()
  134. {
  135.     ST_ResourceHandle    toc = Get1Resource (kClippingTOCResType, kClippingTOCResID);
  136.     if (!(Handle) toc)
  137.         throw resNotFound;
  138.  
  139.     fData = new CClippingFileData (fRefNum);
  140.  
  141.     fClippingTOC = (ClippingTOCHandle)(Handle) toc;
  142.     toc.Forget ();
  143. }
  144.  
  145. CClippingFile::~CClippingFile ()
  146. {
  147.     delete fData;
  148.     CloseResFile (fRefNum);
  149. }
  150.  
  151. CClippingFile*    CClippingFile::NewClippingFile (FSSpec& fileLocation, OSType primaryFlavor)
  152. {
  153.     OSType        fileCreator, fileType;
  154.     
  155.     switch (primaryFlavor) {
  156.         case 'TEXT' :
  157.             fileType = kTextClippingType;
  158.             fileCreator = kFinderClippingSignature;
  159.             break;
  160.         
  161.         case 'snd ' :
  162.             fileType = kSoundClippingType;
  163.             fileCreator = kFinderClippingSignature;
  164.             break;
  165.         
  166.         case 'PICT' :
  167.             fileType = kPictureClippingType;
  168.             fileCreator = kFinderClippingSignature;
  169.             break;
  170.         
  171.         default :
  172.             fileType = kMyClippingType;
  173.             fileCreator = kMyClippingSignature;
  174.     }
  175.     
  176.     ST_ResFileSaver            saver = CurResFile ();
  177.     
  178.     FSpCreateResFile (&fileLocation, fileCreator, fileType, smRoman);
  179.     ST_ResFileCloser        ref = FSpOpenResFile (&fileLocation, fsRdWrPerm);
  180.     if ((short) ref < 0)
  181.         throw ResError ();
  182.         
  183.     // Create an empty table of contents
  184.     ClippingTOCHandle        tocHandle = (ClippingTOCHandle)
  185.             NewHandleClear (sizeof (ClippingTOCRec));
  186.     if (!tocHandle)
  187.         throw ResError ();
  188.     
  189.     (**tocHandle).version = 1;
  190.     
  191.     // Add it to the new clipping file
  192.     AddResource ((Handle) tocHandle, kClippingTOCResType, kClippingTOCResID, "\p");
  193.     OSErr    error = ResError ();
  194.     if (error) {
  195.         DisposeHandle ((Handle) tocHandle);
  196.         throw error;
  197.     }
  198.     
  199.     ST_ResourceHandle        tocHandleKiller = (Handle)tocHandle;
  200.     CClippingFileData::CreateNewClippingFileData (ref);
  201.     
  202.     WriteResource ((Handle) tocHandle);
  203.     
  204.     tocHandleKiller.Forget ();
  205.     short        resFileRefNum = ref;
  206.     ref.Forget ();
  207.     
  208.     return new CClippingFile (resFileRefNum);
  209. }
  210.  
  211. void CClippingFile::AddFlavor (const FlavorType flavorType, const Handle flavorData)
  212. {
  213.     ST_ResFileSaver        saver = CurResFile ();
  214.     UseResFile (fRefNum);
  215.         
  216.     Handle                    flavorRes = Get1Resource (flavorType, kFlavorResID);
  217.     if (flavorRes) {
  218.         RemoveResource (flavorRes);
  219.         DisposeHandle (flavorRes);
  220.         UpdateResFile (fRefNum);
  221.     }
  222.     
  223.     AddResource (flavorData, flavorType, kFlavorResID, "\p");
  224.     OSErr        error = ResError ();
  225.     if (error)
  226.         throw error;
  227.  
  228.     ClippingFlavorRec    flavorRec;
  229.     
  230.     flavorRec.flavorType = flavorType;
  231.     flavorRec.reserved3 = flavorRec.reserved2 = flavorRec.reserved1 = 0;
  232.  
  233.     error = PtrAndHand (&flavorRec, (Handle) fClippingTOC, sizeof (flavorRec));
  234.     if (error)
  235.         throw error;
  236.     
  237.     ++(**fClippingTOC).flavorCount;
  238.     ChangedResource ((Handle) fClippingTOC);
  239. }
  240.  
  241. short CClippingFile::CountFlavors ()
  242. {
  243.     return (**fClippingTOC).flavorCount;
  244. }
  245.  
  246. void CClippingFile::GetIndFlavor (short index, FlavorType& gotFlavor, Handle& gotHandle)
  247. {
  248.     ClippingTOCRec*        clippingTOC = *fClippingTOC;
  249.  
  250.     if (index > clippingTOC -> flavorCount)
  251.         throw paramErr;
  252.  
  253.     FlavorType            flavorType = clippingTOC -> flavors [index - 1].flavorType;
  254.     
  255.     ST_ResFileSaver        saver = CurResFile ();
  256.     UseResFile (fRefNum);
  257.     
  258.     Handle                flavorData = Get1Resource (flavorType, kFlavorResID);
  259.     if (!flavorData)
  260.         throw resNotFound;
  261.     
  262.     gotFlavor = flavorType;
  263.     gotHandle = flavorData;
  264. }
  265.  
  266. void CClippingFile::GetIndFlavorType (short index, FlavorType& gotFlavor)
  267. {
  268.     ClippingTOCRec*        clippingTOC = *fClippingTOC;
  269.  
  270.     if (index > clippingTOC -> flavorCount)
  271.         throw paramErr;
  272.  
  273.     gotFlavor = clippingTOC -> flavors [index - 1].flavorType;
  274. }
  275.     
  276. DragReference CClippingFile::BuildDragReference ()
  277. {
  278.     ST_ResFileSaver        saver = CurResFile ();
  279.     DragReference        dragRef;
  280.  
  281.     OSErr                error = NewDrag (&dragRef);
  282.     if (error)
  283.         throw error;
  284.     
  285.     ST_DragReference    dragReferenceKiller = dragRef;
  286.     short                flavorCount = CountFlavors ();
  287.     
  288.     for (short i = 1; i <= flavorCount; ++i) {
  289.         FlavorType        flavorType;
  290.         Handle            flavorHandle;
  291.         
  292.         GetIndFlavor (i, flavorType, flavorHandle);
  293.         HLock (flavorHandle);
  294.         error = AddDragItemFlavor (dragRef, (ItemReference) 0, flavorType, *flavorHandle,
  295.                 GetHandleSize (flavorHandle), 0);
  296.         ReleaseResource (flavorHandle);
  297.         
  298.         if (error)
  299.             throw error;
  300.     }
  301.     
  302.     dragReferenceKiller.Forget ();
  303.     return dragRef;
  304. }
  305.  
  306. void CClippingFile::AddThumbnail (CThumbnail& thumbnail)
  307. {
  308. }
  309.  
  310. CThumbnail* CClippingFile::GetThumbnail ()
  311. {
  312.     return nil;
  313. }
  314.  
  315. Boolean CClippingFile::GetFSSpec (FSSpec& spec)
  316. {
  317.     FCBPBRec        pb;
  318.     
  319.     pb.ioVRefNum = 0;
  320.     pb.ioFCBIndx = 0;
  321.     pb.ioRefNum = fRefNum;
  322.     pb.ioNamePtr = spec.name;
  323.     spec.name [0] = '\0';
  324.     
  325.     OSErr        error = PBGetFCBInfoSync (&pb);
  326.     if (error)
  327.         return false;
  328.         
  329.     spec.vRefNum = pb.ioFCBVRefNum;
  330.     spec.parID = pb.ioFCBParID;
  331.     return true;
  332. }